﻿using Microsoft.Extensions.Logging;
using RotovapPlatform.Domain.Common;
using RotovapPlatform.Domain.Equipment.Device.Motors;
using RotovapPlatform.Domain.Equipment.Device.Motors.Dto;
using RotovapPlatform.Domain.Equipment.DeviceParameters;
using RotovapPlatform.Domain.Equipment.Interfaces.Base;
using RotovapPlatform.Domain.Equipment.Interfaces.Services;
using RotovapPlatform.Infrastructure.Equipment.Devices.EtherCATMotor;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Threading;

namespace RotovapPlatform.Infrastructure.Services
{
	/// <summary>
	/// 电机控制服务实现类，提供基于工作位置的电机控制功能
	/// </summary>
	public class MotorControlService : IMotorControlService, IDisposable
	{
		private readonly ILogger<MotorControlService> _logger;
		private readonly Dictionary<string, IMotorBase> _motors = new();
		private readonly MotorPositionsCollection _positionsCollection = new();
		private readonly IDeviceParameterService _deviceParameterService;
		private readonly string _configFilePath = "Config/motorPositions.json";
		private bool _disposed = false;
		private bool _isDispensingPaused = false;
		private double _currentDispensedVolume = 0;
		private readonly object _dispensingLock = new object();
		private DeviceParametersEntity _deviceParameters;

		/// <summary>
		/// 构造函数
		/// </summary>
		/// <param name="motors">电机列表</param>
		/// <param name="logger">日志记录器</param>
		/// <param name="deviceParameterService">设备参数服务</param>
		public MotorControlService(
			IEnumerable<IMotorBase> motors,
			ILogger<MotorControlService> logger,
			IDeviceParameterService deviceParameterService)
		{
			Console.WriteLine("MotorControlService 构造函数开始执行");

			_logger = logger;
			_deviceParameterService = deviceParameterService;

			if (motors != null)
			{
				Console.WriteLine($"传入的 motors 集合包含 {motors.Count()} 个电机");

				foreach (var motor in motors)
				{
					if (!string.IsNullOrEmpty(motor.EquipmentId))
					{
						_motors[motor.EquipmentId] = motor;
						Console.WriteLine($"添加电机到 _motors 字典: {motor.EquipmentId} ({motor.Name})");
					}
				}

				Console.WriteLine($"_motors 字典初始化完成，包含 {_motors.Count} 个电机");
			}
			else
			{
				Console.WriteLine("传入的motors集合为空");
			}

			// 初始化工作位置集合
			Console.WriteLine("开始初始化工作位置集合");
			InitializePositions();
			Console.WriteLine("工作位置集合初始化完成");

			// 订阅参数更新事件
			_deviceParameterService.ParametersUpdated += OnDeviceParametersUpdated;

			Console.WriteLine("MotorControlService 构造函数执行完成");
		}

		/// <summary>
		/// 执行电机扭矩控制
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="targetTorque">目标扭矩（千分比）</param>
		/// <param name="torqueChangeRate">扭矩变化率</param>
		/// <param name="maxSpeed">扭矩模式下的最大速度（脉冲/秒）</param>
		/// <param name="timeoutSeconds">超时时间秒</param>
		/// <returns>操作结果</returns>
		public async Task<OperationResult> ExecuteTorqueControlAsync(string motorId, short targetTorque, double torqueChangeRate, uint maxSpeed, int timeoutSeconds = 20)
		{
			try
			{
				// 获取电机实例
				var motor = GetMotor(motorId);
				if (motor == null)
				{
					_logger.LogError($"未找到电机: {motorId}，无法执行扭矩控制");
					return OperationResult.Fail($"未找到电机: {motorId}，无法执行扭矩控制");
				}

				_logger.LogInformation($"开始对电机 {motorId} 执行扭矩控制，目标扭矩: {targetTorque}, 扭矩变化率: {torqueChangeRate}, 最大速度: {maxSpeed}");

				// 步骤1：设置扭矩模式下的最大限速
				_logger.LogInformation($"设置电机 {motorId} 扭矩模式下的最大限速: {maxSpeed}");
				bool setMaxSpeedResult = await motor.SetMaxSpeedAsync(maxSpeed);
				if (!setMaxSpeedResult)
				{
					_logger.LogError($"设置电机 {motorId} 最大限速失败");
					return OperationResult.Fail($"设置电机 {motorId} 最大限速失败");
				}

				// 步骤2：设置模式为扭矩模式(10)
				_logger.LogInformation($"设置电机 {motorId} 为扭矩模式(10)");
				bool setModeResult = await motor.SetModeAsync(10);
				if (!setModeResult)
				{
					_logger.LogError($"设置电机 {motorId} 为扭矩模式失败");
					return OperationResult.Fail($"设置电机 {motorId} 为扭矩模式失败");
				}

				// 步骤3：设置转矩千分比和转矩变化率
				_logger.LogInformation($"设置电机 {motorId} 转矩: {targetTorque}, 变化率: {torqueChangeRate}");
				bool setTorqueResult = await motor.SetTorqueAsync(targetTorque, torqueChangeRate);
				if (!setTorqueResult)
				{
					_logger.LogError($"设置电机 {motorId} 转矩参数失败");
					return OperationResult.Fail($"设置电机 {motorId} 转矩参数失败");
				}

				// 步骤4：持续读取当前转矩，当达到目标转矩且电机不在运动时，设置为位置模式
				_logger.LogInformation($"开始监控电机 {motorId} 转矩和运动状态");

				// 设置最大等待时间（20秒）
				int maxWaitTime = timeoutSeconds; // 20秒（每次等待1s,一秒+1）
				int waitCount = 0;

				//var status = new MotorStatus();

				while (waitCount < maxWaitTime)
				{
					//// 读取当前转矩
					short currentTorque = await motor.GetCurrentTorqueAsync();

					//// 获取电机状态
					//var status = await motor.GetStatusAsync();

					////_logger.LogDebug($"电机 {motorId} 当前转矩: {currentTorque}, 目标转矩: {targetTorque}, 位置状态: {(status.InPosition ? "到位" : "未到位")}");

					// 检查转矩是否达到目标值且电机是否到位
					// 使用接近判断而不是精确相等，允许一定误差范围（这里用10作为误差范围）
					if (Math.Abs(currentTorque - targetTorque) <= 50)//&& status.InPosition)
					{
						_logger.LogInformation($"电机 {motorId} 已达到目标转矩且停止运动，当前转矩: {currentTorque}");

						// 设置转矩千分比为0和转矩变化率
						_logger.LogInformation($"设置电机 {motorId} 转矩: {0}, 变化率: {torqueChangeRate}");
						bool setTorque0Result = await motor.SetTorqueAsync(0, torqueChangeRate);
						if (!setTorque0Result)
						{
							_logger.LogError($"设置电机 {motorId} 转矩参数失败");
							return OperationResult.Fail($"设置电机 {motorId} 转矩参数失败");
						}

						// 等待当前力矩实际降为0
						_logger.LogInformation($"等待电机 {motorId} 实际转矩降为0");
						int maxWaitForZeroTorque = 8; // 最多等待8秒(1s+5)
						int waitZeroCount = 0;

						while (waitZeroCount < maxWaitForZeroTorque)
						{
							// 读取当前转矩
							short actualTorque = await motor.GetCurrentTorqueAsync();
							_logger.LogDebug($"电机 {motorId} 当前实际转矩: {actualTorque}");

							// 如果转矩已接近0（允许±5误差），则跳出循环
							if (Math.Abs(actualTorque) <= 5)
							{
								_logger.LogInformation($"电机 {motorId} 转矩已降为0附近，当前值: {actualTorque}");
								break;
							}

							// 等待一段时间再检查
							await Task.Delay(1000);
							waitZeroCount++;
						}

						// 延迟100ms
						_logger.LogInformation($"电机 {motorId} 转矩已降为0，延迟100ms");
						await Task.Delay(1000);

						// 切换回位置模式(8)
						_logger.LogInformation($"将电机 {motorId} 切换回位置模式(8)");
						bool switchToPositionResult = await motor.SetModeAsync(8);
						if (!switchToPositionResult)
						{
							_logger.LogError($"将电机 {motorId} 切换回位置模式失败");
							return OperationResult.Fail($"将电机 {motorId} 切换回位置模式失败");
						}

						return OperationResult.Ok($"电机 {motorId} 扭矩控制成功，已达到目标转矩: {currentTorque}");
					}

					// 等待一段时间再检查
					await Task.Delay(1000);
					waitCount++;
				}

				// 如果达到最大等待时间仍未完成
				_logger.LogWarning($"电机 {motorId} 扭矩控制超时，未能在规定时间内达到目标状态");

				// 设置转矩千分比为0和转矩变化率
				_logger.LogInformation($"设置电机 {motorId} 转矩: {0}, 变化率: {torqueChangeRate}");
				bool setTorque0Result2 = await motor.SetTorqueAsync(0, torqueChangeRate);
				if (!setTorque0Result2)
				{
					_logger.LogError($"设置电机 {motorId} 转矩参数失败");
					return OperationResult.Fail($"设置电机 {motorId} 转矩参数失败");
				}

				// 尝试切换回位置模式
				_logger.LogInformation($"尝试将电机 {motorId} 切换回位置模式(8)");
				bool fallbackSwitchResult = await motor.SetModeAsync(8);
				if (!fallbackSwitchResult)
				{
					_logger.LogError($"将电机 {motorId} 切换回位置模式失败");
				}

				return OperationResult.Fail($"电机 {motorId} 扭矩控制超时，未能在规定时间内达到目标状态");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"执行电机 {motorId} 扭矩控制时发生异常");

				// 尝试切换回位置模式
				try
				{
					var motor = GetMotor(motorId);

					// 设置转矩千分比为0和转矩变化率
					_logger.LogInformation($"设置电机 {motorId} 转矩: {0}, 变化率: {torqueChangeRate}");
					bool setTorque0Result3 = await motor.SetTorqueAsync(0, torqueChangeRate);
					if (!setTorque0Result3)
					{
						_logger.LogError($"设置电机 {motorId} 转矩参数失败");
						return OperationResult.Fail($"设置电机 {motorId} 转矩参数失败");
					}
					await motor.SetModeAsync(8);
				}
				catch (Exception innerEx)
				{
					_logger.LogError(innerEx, $"恢复电机 {motorId} 模式时发生异常");
				}

				return OperationResult.Fail($"执行扭矩控制失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 初始化电机控制服务
		/// </summary>
		/// <returns>是否初始化成功</returns>
		public async Task<OperationResult> InitializeAsync()
		{
			try
			{
				Console.WriteLine("MotorControlService.InitializeAsync 方法开始执行");
				_logger.LogInformation("开始初始化电机控制服务");

				// 检查现有配置文件
				bool needReloadFromDeviceParams = false;
				if (File.Exists(_configFilePath))
				{
					try
					{
						// 读取文件内容
						string json = await File.ReadAllTextAsync(_configFilePath);

						// 检查文件内容是否只包含少量电机
						using (JsonDocument doc = JsonDocument.Parse(json))
						{
							int motorCount = doc.RootElement.EnumerateObject().Count();
							Console.WriteLine($"配置文件中包含 {motorCount} 个电机");

							// 如果只有默认的少量电机，尝试从设备参数重新加载
							if (motorCount <= 2)
							{
								Console.WriteLine("配置文件中只包含少量电机，将从设备参数重新加载");
								needReloadFromDeviceParams = true;

								// 备份原有文件
								string backupPath = $"{_configFilePath}.backup.{DateTime.Now:yyyyMMddHHmmss}";
								File.Copy(_configFilePath, backupPath);
								Console.WriteLine($"已将原配置文件备份为: {backupPath}");

								// 删除现有配置文件
								File.Delete(_configFilePath);
								Console.WriteLine("已删除现有配置文件，将重新创建");
							}
						}
					}
					catch (Exception ex)
					{
						Console.WriteLine($"解析配置文件时发生错误: {ex.Message}，将从设备参数重新加载");
						_logger.LogError(ex, "解析配置文件时发生错误，将从设备参数重新加载");
						needReloadFromDeviceParams = true;
					}
				}
				else
				{
					Console.WriteLine("配置文件不存在，将从设备参数加载");
					needReloadFromDeviceParams = true;
				}

				// 如果需要从设备参数加载
				if (needReloadFromDeviceParams)
				{
					Console.WriteLine("开始从设备参数加载电机位置配置");
					await SyncPositionsFromDeviceParametersAsync();
				}
				else
				{
					// 否则尝试从配置文件加载
					Console.WriteLine("尝试从配置文件加载电机位置配置");
					var loadResult = await LoadPositionConfigAsync();
					if (!loadResult.Success)
					{
						// 加载失败，尝试从设备参数加载
						Console.WriteLine("从配置文件加载电机位置配置失败，尝试从设备参数加载");
						await SyncPositionsFromDeviceParametersAsync();
					}
				}

				// 确保所有电机都有工作位置
				await EnsureAllMotorsHavePositionsAsync();

				_logger.LogInformation("电机控制服务初始化成功");
				return OperationResult.Ok("电机控制服务初始化成功");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, "初始化电机控制服务失败");
				return OperationResult.Fail($"初始化电机控制服务失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 从设备参数同步电机工作位置配置
		/// </summary>
		/// <returns>操作结果</returns>
		public async Task<OperationResult> SyncPositionsFromDeviceParametersAsync()
		{
			try
			{
				_logger.LogInformation("开始从设备参数同步电机工作位置配置");

				// 获取所有电机参数
				var deviceParams = await _deviceParameterService.GetParametersAsync();
				if (deviceParams?.Motors == null || deviceParams.Motors.Count == 0)
				{
					_logger.LogWarning("设备参数中没有电机配置");
					return OperationResult.Fail("设备参数中没有电机配置");
				}

				// 加载电机工作位置
				_positionsCollection.LoadFromDeviceParameters(deviceParams.Motors);

				// 保存到文件
				if (_positionsCollection.SaveToFile(_configFilePath))
				{
					_logger.LogInformation("从设备参数同步工作位置配置并保存成功");
					return OperationResult.Ok("从设备参数同步工作位置配置并保存成功");
				}
				else
				{
					_logger.LogWarning("从设备参数同步工作位置配置成功，但保存到文件失败");
					return OperationResult.Fail("保存工作位置配置到文件失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, "从设备参数同步电机工作位置配置失败");
				return OperationResult.Fail($"从设备参数同步电机工作位置配置失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 确保所有电机都有工作位置配置
		/// </summary>
		private async Task EnsureAllMotorsHavePositionsAsync()
		{
			try
			{
				// 获取所有注册的电机
				var registeredMotors = _motors.Keys.ToList();
				var deviceParams = await _deviceParameterService.GetParametersAsync();

				// 对每个电机检查是否有工作位置
				foreach (var motorId in registeredMotors)
				{
					var positions = _positionsCollection.GetPositionNames(motorId);

					// 如果没有工作位置，尝试从设备参数创建
					if (!positions.Any())
					{
						_logger.LogWarning($"电机 {motorId} 没有工作位置配置，尝试从设备参数创建");

						// 查找设备参数中的对应电机
						var motorParam = deviceParams.Motors.FirstOrDefault(m => m.Id == motorId);
						if (motorParam != null && motorParam.WorkPositions != null && motorParam.WorkPositions.Any())
						{
							// 从设备参数中加载工作位置
							foreach (var workPos in motorParam.WorkPositions)
							{
								_positionsCollection.AddPosition(
									motorId,
									workPos.Name,
									workPos.Position,
									workPos.Speed,
									workPos.Acceleration,
									workPos.Deceleration,
									10.0 // 默认位置容差
								);
							}

							_logger.LogInformation($"已为电机 {motorId} 从设备参数创建了 {motorParam.WorkPositions.Count} 个工作位置");
						}
						else
						{
							// 创建默认配置
							_logger.LogWarning($"设备参数中没有电机 {motorId} 的工作位置，创建默认配置");

							// 根据电机ID决定创建什么样的默认位置
							if (motorId.Contains("Lift", StringComparison.OrdinalIgnoreCase))
							{
								// 升降电机
								_positionsCollection.AddPosition(motorId, "上升位置", 0, 1000, 500, 500);
								_positionsCollection.AddPosition(motorId, "下降位置", 100, 1000, 500, 500);
							}
							else if (motorId.Contains("Rotary", StringComparison.OrdinalIgnoreCase))
							{
								// 旋转电机
								_positionsCollection.AddPosition(motorId, "初始位置", 0, 2000, 1000, 1000);
								_positionsCollection.AddPosition(motorId, "工作位置", 180, 2000, 1000, 1000);
							}
							else
							{
								// 通用电机
								_positionsCollection.AddPosition(motorId, "初始位置", 0, 1500, 800, 800);
								_positionsCollection.AddPosition(motorId, "工作位置", 50, 1500, 800, 800);
							}

							_logger.LogInformation($"已为电机 {motorId} 创建默认工作位置");
						}
					}
				}

				// 保存配置
				_positionsCollection.SaveToFile(_configFilePath);
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, "确保所有电机都有工作位置配置时出错");
			}
		}

		/// <summary>
		/// 从设备参数中设置电机参数
		/// </summary>
		/// <param name="motors">电机列表</param>
		private async Task SetMotorParametersFromDeviceParams(IEnumerable<RotovapPlatform.Domain.Equipment.DeviceParameters.Motor> motors)
		{
			try
			{
				Console.WriteLine("MotorControlService.SetMotorParametersFromDeviceParams 方法开始执行");
				Console.WriteLine($"输入的电机配置数量: {motors?.Count() ?? 0}");

				var availableMotors = await GetMotorsAsync();
				Console.WriteLine($"GetMotorsAsync 返回的电机数量: {availableMotors?.Count() ?? 0}");

				if (!availableMotors.Any())
				{
					Console.WriteLine("没有可用的电机实例，无法设置参数");
					return;
				}

				foreach (var motor in availableMotors)
				{
					var motorId = motor.EquipmentId;
					Console.WriteLine($"处理电机: {motorId}, 轴号: {motor.AxisNo}");

					// 尝试通过ID匹配
					var motorConfig = motors.FirstOrDefault(m => m.Id == motorId);

					// 如果通过ID没有找到，尝试通过轴号匹配
					if (motorConfig == null)
					{
						Console.WriteLine($"通过ID未找到电机 {motorId} 的配置，尝试通过轴号匹配");
						motorConfig = motors.FirstOrDefault(m => m.AxisId == motor.AxisNo);
					}

					if (motorConfig == null)
					{
						Console.WriteLine($"未找到电机 {motorId} (轴号: {motor.AxisNo}) 的配置");
						continue;
					}

					if (motorConfig.Parameters == null)
					{
						Console.WriteLine($"电机 {motorId} 的参数配置为null");
						continue;
					}

					Console.WriteLine($"为电机 {motorId} (轴号: {motor.AxisNo}) 设置参数");
					_logger.LogInformation($"为电机 {motorId} 设置参数");

					// 如果电机有实现IMotorBase接口的SetMotorParameters方法
					if (motor is EtherCATMotorDrive etherCATMotor)
					{
						Console.WriteLine($"电机 {motorId} 是 EtherCATMotorDrive 类型");
						try
						{
							etherCATMotor.SetMotorParameters(motorConfig.Parameters);
							Console.WriteLine($"电机 {motorId} 参数设置成功");
						}
						catch (Exception ex)
						{
							Console.WriteLine($"设置电机 {motorId} 参数时出错: {ex.Message}");
							Console.WriteLine($"异常堆栈: {ex.StackTrace}");
						}
					}
					else
					{
						Console.WriteLine($"电机 {motorId} 不是 EtherCATMotorDrive 类型，无法设置参数");
					}
				}
				Console.WriteLine("MotorControlService.SetMotorParametersFromDeviceParams 方法执行结束");
			}
			catch (Exception ex)
			{
				Console.WriteLine($"设置电机参数时发生错误: {ex.Message}");
				Console.WriteLine($"异常堆栈: {ex.StackTrace}");
				_logger.LogError(ex, "设置电机参数时发生错误");
			}
		}

		/// <summary>
		/// 获取所有电机列表
		/// </summary>
		/// <returns>电机列表</returns>
		public Task<IEnumerable<IMotorBase>> GetMotorsAsync()
		{
			Console.WriteLine("MotorControlService.GetMotorsAsync 方法被调用");
			Console.WriteLine($"当前 _motors 字典中包含 {_motors.Count} 个电机");

			// 直接返回现有电机列表
			return Task.FromResult<IEnumerable<IMotorBase>>(_motors.Values);
		}

		/// <summary>
		/// 获取所有已注册的电机
		/// </summary>
		/// <returns>电机列表</returns>
		public async Task<List<IMotorBase>> GetRegisteredMotorsAsync()
		{
			Console.WriteLine("MotorControlService.GetRegisteredMotorsAsync 方法被调用");
			Console.WriteLine($"当前 _motors 字典中包含 {_motors.Count} 个电机");

			// 使用GetMotorsAsync的结果并转换为List
			var motors = await GetMotorsAsync();
			var motorsList = motors.ToList();

			Console.WriteLine($"返回 {motorsList.Count} 个已注册电机");
			return motorsList;
		}

		/// <summary>
		/// 获取特定ID的电机
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>电机实例</returns>
		public async Task<IMotorBase> GetMotorAsync(string motorId)
		{
			// 获取电机列表
			var motors = await GetMotorsAsync();

			// 根据ID查找电机
			var motor = motors.FirstOrDefault(m => m.EquipmentId == motorId);

			if (motor == null)
			{
				_logger.LogWarning($"未找到ID为{motorId}的电机");
			}

			return motor;
		}

		/// <summary>
		/// 检查并获取电机
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>电机对象</returns>
		private IMotorBase GetMotor(string motorId)
		{
			if (string.IsNullOrEmpty(motorId))
				throw new ArgumentException("电机ID不能为空", nameof(motorId));

			if (!_motors.TryGetValue(motorId, out var motor))
				throw new KeyNotFoundException($"未找到电机: {motorId}");

			return motor;
		}

		/// <summary>
		/// 使能电机
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> EnableMotorAsync(string motorId)
		{
			try
			{
				var motor = GetMotor(motorId);
				_logger.LogInformation($"使能电机: {motorId}");
				bool result = await motor.EnableAsync();

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} 使能成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} 使能失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"使能电机失败: {motorId}");
				return OperationResult.Fail($"使能电机失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 去使能电机
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> DisableMotorAsync(string motorId)
		{
			try
			{
				var motor = GetMotor(motorId);
				_logger.LogInformation($"去使能电机: {motorId}");
				bool result = await motor.DisableAsync();

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} 去使能成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} 去使能失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"去使能电机失败: {motorId}");
				return OperationResult.Fail($"去使能电机失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 电机回零
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> HomeMotorAsync(string motorId)
		{
			try
			{
				var motor = GetMotor(motorId);
				_logger.LogInformation($"电机回零: {motorId}");
				bool result = await motor.HomeAsync();

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} 回零成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} 回零失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"电机回零失败: {motorId}");
				return OperationResult.Fail($"电机回零失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 将电机移动到指定的工作位置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="positionName">位置名称</param>
		/// <returns>操作是否成功</returns>
		public async Task<OperationResult> MoveToPositionAsync(string motorId, string positionName)
		{
			try
			{
				// 获取电机
				var motor = GetMotor(motorId);
				if (motor == null)
				{
					_logger.LogError($"未找到电机: {motorId}，无法移动到位置 {positionName}");
					return OperationResult.Fail($"未找到电机: {motorId}，无法移动到位置 {positionName}");
				}

				// 从位置集合中获取指定工作位置的配置
				var positionConfig = _positionsCollection.GetPosition(motorId, positionName);
				if (positionConfig == null)
				{
					_logger.LogError($"电机{motorId}没有定义位置{positionName}");
					return OperationResult.Fail($"电机{motorId}没有定义位置{positionName}");
				}

				// 从设备参数中获取最新的工作位置配置
				try
				{
					// 获取电机参数
					var motorParams = await _deviceParameterService.GetMotorAsync(motorId);
					if (motorParams != null)
					{
						// 查找对应名称的工作位置
						var updatedPosition = motorParams.WorkPositions?.FirstOrDefault(p => p.Name == positionName);
						if (updatedPosition != null)
						{
							// 更新位置配置
							_logger.LogInformation($"从设备参数中获取到最新的工作位置 {positionName} 配置：位置={updatedPosition.Position}, 速度={updatedPosition.Speed}");
							positionConfig.Position = updatedPosition.Position;
							positionConfig.Speed = updatedPosition.Speed;
							positionConfig.Acceleration = updatedPosition.Acceleration;
							positionConfig.Deceleration = updatedPosition.Deceleration;
						}
					}
				}
				catch (Exception ex)
				{
					_logger.LogWarning(ex, $"获取电机 {motorId} 的设备参数失败，将使用位置集合中的配置");
				}

				// 检查电机状态
				var status = await motor.GetStatusAsync();

				// 如果电机离线，则返回错误
				if (status.Offline)
				{
					_logger.LogError($"电机{motorId}离线，无法移动");
					return OperationResult.Fail($"电机{motorId}离线，无法移动");
				}

				try
				{
					// 如果电机未使能，则先使能电机
					if (!status.Enabled)
					{
						_logger.LogInformation($"电机{motorId}未使能，尝试使能电机");
						var enableResult = await motor.EnableAsync();
						if (!enableResult)
						{
							_logger.LogError($"无法使能电机{motorId}");
							return OperationResult.Fail($"无法使能电机{motorId}");
						}
					}

					// 如果电机未回零，则先回零
					if (!status.Homed)
					{
						_logger.LogInformation($"电机{motorId}未回零，尝试回零");
						var homeResult = await motor.HomeAsync();
						if (!homeResult)
						{
							_logger.LogError($"无法回零电机{motorId}");
							return OperationResult.Fail($"无法回零电机{motorId}");
						}
					}

					// 执行绝对运动
					_logger.LogInformation($"将电机{motorId}移动到位置{positionName}，绝对位置为{positionConfig.Position}");

					// 使用完整的参数集合进行运动
					var result = await motor.AbsoluteMoveAsync(
						positionConfig.Position,
						positionConfig.Speed,
						positionConfig.Acceleration,
						positionConfig.Deceleration);

					if (result)
					{
						_logger.LogInformation($"电机{motorId}移动到位置{positionName}成功");
						return OperationResult.Ok($"电机{motorId}移动到位置{positionName}成功");
					}
					else
					{
						_logger.LogError($"电机{motorId}移动到位置{positionName}失败");
						return OperationResult.Fail($"电机{motorId}移动到位置{positionName}失败");
					}
				}
				catch (Exception ex)
				{
					_logger.LogError(ex, $"移动电机{motorId}到位置{positionName}时发生异常");
					return OperationResult.Fail($"移动电机时发生异常: {ex.Message}");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"移动电机 {motorId} 到位置 {positionName} 失败");
				return OperationResult.Fail($"移动电机失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 移动电机到指定位置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="position">目标位置</param>
		/// <param name="speed">移动速度</param>
		/// <param name="acceleration">加速度</param>
		/// <param name="deceleration">减速度</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> MoveToPositionAsync(string motorId, double position, double speed, double acceleration, double deceleration)
		{
			try
			{
				var motor = GetMotor(motorId);

				_logger.LogInformation($"移动电机 {motorId} 到位置 {position}，速度: {speed}");

				// 使用扩展的AbsoluteMoveAsync方法，传递完整参数
				bool result = await motor.AbsoluteMoveAsync(position, speed, acceleration, deceleration);

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} 移动到位置 {position} 成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} 移动到位置 {position} 失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"移动电机 {motorId} 到位置 {position} 失败");
				return OperationResult.Fail($"移动电机失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 判断电机是否在指定工作位置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="positionName">工作位置名称</param>
		/// <returns>是否在指定位置</returns>
		public async Task<OperationResult<bool>> IsAtPositionAsync(string motorId, string positionName)
		{
			try
			{
				var motor = GetMotor(motorId);

				// 获取位置配置
				var posConfig = _positionsCollection.GetPosition(motorId, positionName);
				if (posConfig == null)
				{
					_logger.LogError($"未找到电机 {motorId} 的工作位置 {positionName}");
					return OperationResult<bool>.Fail($"未找到电机 {motorId} 的工作位置 {positionName}");
				}

				// 获取电机状态
				var status = await motor.GetStatusAsync();

				// 检查是否离线
				if (status.Offline)
				{
					_logger.LogError($"电机 {motorId} 离线，无法检查位置");
					return OperationResult<bool>.Fail($"电机 {motorId} 离线，无法检查位置");
				}

				// 检查实际位置与目标位置的差异
				double diff = Math.Abs(status.Actual_P - posConfig.Position);
				bool atPosition = diff <= posConfig.PositionTolerance;

				_logger.LogInformation($"电机 {motorId} 当前位置: {status.Actual_P}，目标位置: {posConfig.Position}，差异: {diff}，容差: {posConfig.PositionTolerance}，是否到达: {atPosition}");

				return OperationResult<bool>.Ok(atPosition, $"电机 {motorId} 位置检查完成");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"检查电机 {motorId} 是否在位置 {positionName} 时发生错误");
				return OperationResult<bool>.Fail($"检查电机位置时发生错误: {ex.Message}");
			}
		}

		/// <summary>
		/// 电机JOG+运动
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="speed">运行速度（可选），如果不指定则使用电机参数中定义的jogSpeed</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> JogPlusAsync(string motorId, double? speed = null)
		{
			try
			{
				var motor = GetMotor(motorId);

				// 获取电机参数
				var motorParams = await _deviceParameterService.GetMotorAsync(motorId);
				if (motorParams == null)
				{
					return OperationResult.Fail($"电机 {motorId} 参数不存在");
				}

				// 使用传入的速度或默认使用电机参数中定义的jogSpeed
				double jogSpeed = speed ?? motorParams.Parameters.JogSpeed;

				_logger.LogInformation($"电机 {motorId} JOG+运动，速度: {jogSpeed}");
				bool result = await motor.JogPlusAsync(jogSpeed);

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} JOG+运动成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} JOG+运动失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"电机 {motorId} JOG+运动失败");
				return OperationResult.Fail($"电机JOG+运动失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 电机JOG-运动
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="speed">运行速度（可选），如果不指定则使用电机参数中定义的jogSpeed</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> JogMinusAsync(string motorId, double? speed = null)
		{
			try
			{
				var motor = GetMotor(motorId);

				// 获取电机参数
				var motorParams = await _deviceParameterService.GetMotorAsync(motorId);
				if (motorParams == null)
				{
					return OperationResult.Fail($"电机 {motorId} 参数不存在");
				}

				// 使用传入的速度或默认使用电机参数中定义的jogSpeed
				double jogSpeed = speed ?? motorParams.Parameters.JogSpeed;

				_logger.LogInformation($"电机 {motorId} JOG-运动，速度: {jogSpeed}");
				bool result = await motor.JogMinusAsync(jogSpeed);

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} JOG-运动成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} JOG-运动失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"电机 {motorId} JOG-运动失败");
				return OperationResult.Fail($"电机JOG-运动失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 停止电机
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> StopMotorAsync(string motorId)
		{
			try
			{
				var motor = GetMotor(motorId);
				_logger.LogInformation($"停止电机 {motorId}");
				bool result = await motor.StopJogAsync();

				if (result)
				{
					return OperationResult.Ok($"电机 {motorId} 停止成功");
				}
				else
				{
					return OperationResult.Fail($"电机 {motorId} 停止失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"停止电机 {motorId} 失败");
				return OperationResult.Fail($"停止电机失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 复位轴
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>操作结果</returns>
		public async Task<OperationResult> ResetAxisAsync(string motorId)
		{
			try
			{
				var motor = GetMotor(motorId);
				if (motor == null)
				{
					_logger.LogError($"未找到电机: {motorId}，无法复位轴");
					return OperationResult.Fail($"未找到电机: {motorId}，无法复位轴");
				}

				_logger.LogInformation($"开始复位轴 {motorId}");
				bool result = await motor.ResetAxisAsync();

				if (result)
				{
					_logger.LogInformation($"轴 {motorId} 复位成功");
					return OperationResult.Ok($"轴 {motorId} 复位成功");
				}
				else
				{
					_logger.LogError($"轴 {motorId} 复位失败");
					return OperationResult.Fail($"轴 {motorId} 复位失败");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"复位轴 {motorId} 时发生异常");
				return OperationResult.Fail($"复位轴失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 获取电机状态
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>电机状态</returns>
		public async Task<MotorStatus> GetMotorStatusAsync(string motorId)
		{
			try
			{
				var motor = GetMotor(motorId);
				return await motor.GetStatusAsync();
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"获取电机 {motorId} 状态失败");
				return new MotorStatus { Offline = true };
			}
		}

		/// <summary>
		/// 获取所有已配置的电机ID
		/// </summary>
		/// <returns>电机ID集合</returns>
		public Task<IEnumerable<string>> GetAllMotorIdsAsync()
		{
			return Task.FromResult<IEnumerable<string>>(_motors.Keys.ToList());
		}

		/// <summary>
		/// 获取电机的所有工作位置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>工作位置名称集合</returns>
		public async Task<IEnumerable<string>> GetMotorPositionsAsync(string motorId)
		{
			try
			{
				// 首先从设备参数中获取最新的工作位置列表
				var motorParams = await _deviceParameterService.GetMotorAsync(motorId);
				if (motorParams != null && motorParams.WorkPositions != null && motorParams.WorkPositions.Count > 0)
				{
					_logger.LogInformation($"从设备参数中获取电机 {motorId} 的工作位置，共 {motorParams.WorkPositions.Count} 个");
					return motorParams.WorkPositions.Select(p => p.Name).ToList();
				}

				// 如果设备参数中没有找到，则从位置集合中获取
				_logger.LogWarning($"未在设备参数中找到电机 {motorId} 的工作位置，尝试从位置集合中获取");
				var positions = _positionsCollection.GetPositionNames(motorId);
				return positions;
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"获取电机 {motorId} 的工作位置失败");
				return Enumerable.Empty<string>();
			}
		}

		/// <summary>
		/// 学习当前位置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="positionName">位置名称</param>
		/// <param name="speed">移动速度</param>
		/// <param name="acceleration">加速度</param>
		/// <param name="deceleration">减速度</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> LearnCurrentPositionAsync(string motorId, string positionName, double? speed = null, double? acceleration = null, double? deceleration = null)
		{
			try
			{
				// 获取电机
				var motor = GetMotor(motorId);

				// 获取电机状态
				var status = await motor.GetStatusAsync();

				// 检查是否离线
				if (status.Offline)
				{
					_logger.LogError($"电机 {motorId} 离线，无法学习位置");
					return OperationResult.Fail($"电机 {motorId} 离线，无法学习位置");
				}

				// 获取所有位置配置
				var positions = _positionsCollection.GetAllPositions(motorId);

				// 如果不存在默认配置，先创建
				var config = _positionsCollection.GetPosition(motorId, positionName);
				if (config == null)
				{
					// 如果有其他位置，使用其配置作为模板
					if (positions.Count > 0)
					{
						var template = positions.Values.First();
						config = new MotorPositionConfig
						{
							Position = status.Actual_P,
							Speed = speed ?? template.Speed,
							Acceleration = acceleration ?? template.Acceleration,
							Deceleration = deceleration ?? template.Deceleration,
							PositionTolerance = template.PositionTolerance
						};
					}
					else
					{
						// 如果没有任何配置，使用默认值
						config = new MotorPositionConfig
						{
							Position = status.Actual_P,
							Speed = speed ?? 50.0,
							Acceleration = acceleration ?? 25.0,
							Deceleration = deceleration ?? 25.0,
							PositionTolerance = 10.0
						};
					}
				}
				else
				{
					// 更新位置值，保留其他参数
					config.Position = status.Actual_P;
					if (speed.HasValue) config.Speed = speed.Value;
					if (acceleration.HasValue) config.Acceleration = acceleration.Value;
					if (deceleration.HasValue) config.Deceleration = deceleration.Value;
				}

				// 添加或更新位置配置
				_positionsCollection.AddOrUpdatePosition(motorId, positionName, config);

				// 保存配置
				var saveResult = await SavePositionConfigAsync();
				if (!saveResult.Success)
				{
					return OperationResult.Fail($"学习位置成功但保存配置失败: {saveResult.Message}");
				}

				_logger.LogInformation($"电机 {motorId} 学习位置 {positionName} 成功，位置值: {status.Actual_P}");

				return OperationResult.Ok($"电机 {motorId} 学习位置 {positionName} 成功，位置值: {status.Actual_P}");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"电机 {motorId} 学习位置 {positionName} 失败");
				return OperationResult.Fail($"学习位置失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 保存电机位置配置
		/// </summary>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> SavePositionConfigAsync()
		{
			try
			{
				// 确保配置目录存在
				var configDir = Path.GetDirectoryName(_configFilePath);
				if (!string.IsNullOrEmpty(configDir) && !Directory.Exists(configDir))
				{
					Directory.CreateDirectory(configDir);
				}

				// 序列化位置配置
				var json = _positionsCollection.ToJson();

				// 写入文件
				await File.WriteAllTextAsync(_configFilePath, json);

				_logger.LogInformation($"电机位置配置保存成功: {_configFilePath}");

				return OperationResult.Ok($"电机位置配置保存成功: {_configFilePath}");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"保存电机位置配置失败: {_configFilePath}");
				return OperationResult.Fail($"保存电机位置配置失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 加载电机位置配置
		/// </summary>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> LoadPositionConfigAsync()
		{
			try
			{
				// 检查配置文件是否存在
				if (!File.Exists(_configFilePath))
				{
					_logger.LogWarning($"电机位置配置文件不存在: {_configFilePath}");
					Console.WriteLine($"电机位置配置文件不存在: {_configFilePath}，将创建默认配置");
					return OperationResult.Fail($"电机位置配置文件不存在: {_configFilePath}");
				}

				// 记录文件信息
				var fileInfo = new FileInfo(_configFilePath);
				Console.WriteLine($"电机位置配置文件: {_configFilePath}, 大小: {fileInfo.Length} 字节");

				// 添加超时处理，避免文件读取卡住
				var readTask = File.ReadAllTextAsync(_configFilePath);
				var timeoutTask = Task.Delay(5000); // 设置5秒超时

				if (await Task.WhenAny(readTask, timeoutTask) == timeoutTask)
				{
					// 读取超时
					_logger.LogWarning($"读取电机位置配置文件超时: {_configFilePath}");
					Console.WriteLine($"读取电机位置配置文件超时: {_configFilePath}，将使用默认配置");
					return OperationResult.Fail($"读取电机位置配置文件超时");
				}

				// 读取配置文件
				var json = await readTask;
				Console.WriteLine($"已读取配置文件内容，长度: {json.Length} 字节");

				// 如果文件内容为空，返回失败
				if (string.IsNullOrWhiteSpace(json))
				{
					_logger.LogWarning($"电机位置配置文件内容为空: {_configFilePath}");
					Console.WriteLine($"电机位置配置文件内容为空: {_configFilePath}，将使用默认配置");
					return OperationResult.Fail($"电机位置配置文件内容为空");
				}

				// 如果文件内容过长，只打印前200个字符
				if (json.Length > 0)
				{
					var preview = json.Length > 200 ? json.Substring(0, 200) + "..." : json;
					Console.WriteLine($"文件内容预览: {preview}");
				}

				// 反序列化
				Console.WriteLine("开始将JSON内容加载到位置集合");
				_positionsCollection.LoadFromJson(json);
				Console.WriteLine($"JSON内容加载完成，当前位置集合中有 {_positionsCollection.GetAllMotorIds().Count()} 个电机");

				// 记录所有加载的电机ID和位置
				foreach (var motorId in _positionsCollection.GetAllMotorIds())
				{
					var positions = _positionsCollection.GetPositionNames(motorId);
					Console.WriteLine($"电机 {motorId} 的位置: {string.Join(", ", positions)}");
				}

				_logger.LogInformation($"电机位置配置加载成功: {_configFilePath}");

				return OperationResult.Ok($"电机位置配置加载成功: {_configFilePath}");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"加载电机位置配置失败: {_configFilePath}");
				Console.WriteLine($"加载电机位置配置失败: {ex.Message}");
				Console.WriteLine($"异常堆栈: {ex.StackTrace}");

				// 出现异常时，返回失败但不抛出异常，让程序继续运行
				return OperationResult.Fail($"加载电机位置配置失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 获取电机位置配置详情
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="positionName">位置名称</param>
		/// <returns>位置配置</returns>
		public Task<MotorPositionConfig> GetPositionConfigAsync(string motorId, string positionName)
		{
			return Task.FromResult(_positionsCollection.GetPosition(motorId, positionName));
		}

		/// <summary>
		/// 更新位置配置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="positionName">位置名称</param>
		/// <param name="config">位置配置</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> UpdatePositionConfigAsync(string motorId, string positionName, MotorPositionConfig config)
		{
			try
			{
				_positionsCollection.AddOrUpdatePosition(motorId, positionName, config);
				var saveResult = await SavePositionConfigAsync();
				if (!saveResult.Success)
				{
					return OperationResult.Fail($"更新位置配置成功但保存失败: {saveResult.Message}");
				}

				_logger.LogInformation($"更新电机 {motorId} 位置 {positionName} 配置成功");

				return OperationResult.Ok($"更新电机 {motorId} 位置 {positionName} 配置成功");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"更新电机 {motorId} 位置 {positionName} 配置失败");
				return OperationResult.Fail($"更新位置配置失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 删除位置配置
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <param name="positionName">位置名称</param>
		/// <returns>是否成功</returns>
		public async Task<OperationResult> DeletePositionAsync(string motorId, string positionName)
		{
			try
			{
				var result = _positionsCollection.RemovePosition(motorId, positionName);
				if (result)
				{
					var saveResult = await SavePositionConfigAsync();
					if (!saveResult.Success)
					{
						return OperationResult.Fail($"删除位置成功但保存配置失败: {saveResult.Message}");
					}

					_logger.LogInformation($"删除电机 {motorId} 位置 {positionName} 配置成功");
					return OperationResult.Ok($"删除电机 {motorId} 位置 {positionName} 配置成功");
				}
				else
				{
					return OperationResult.Fail($"删除电机 {motorId} 位置 {positionName} 配置失败，可能不存在该位置");
				}
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"删除电机 {motorId} 位置 {positionName} 配置失败");
				return OperationResult.Fail($"删除位置配置失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 初始化位置集合
		/// </summary>
		private void InitializePositions()
		{
			try
			{
				Console.WriteLine("开始初始化电机位置集合 InitializePositions");

				// 尝试从文件加载位置配置
				if (File.Exists(_configFilePath))
				{
					Console.WriteLine($"发现工作位置配置文件: {_configFilePath}，尝试加载");

					try
					{
						if (_positionsCollection.LoadFromFile(_configFilePath))
						{
							var motorIds = _positionsCollection.GetAllMotorIds().ToList();
							Console.WriteLine($"从文件加载电机位置配置成功，加载了 {motorIds.Count} 个电机的工作位置");

							if (motorIds.Count > 2)
							{
								// 如果已经加载了超过默认的2个电机，说明配置是完整的，直接返回
								_logger.LogInformation($"从文件加载了 {motorIds.Count} 个电机的工作位置配置");
								return;
							}
							else
							{
								// 如果只加载了少量电机，可能是旧的默认配置，尝试从设备参数加载
								Console.WriteLine("加载的电机数量较少，可能是旧的默认配置，将尝试从设备参数加载");
							}
						}
						else
						{
							Console.WriteLine("从文件加载电机位置配置失败，将尝试从设备参数加载");
						}
					}
					catch (Exception ex)
					{
						Console.WriteLine($"从文件加载电机位置配置异常: {ex.Message}，将尝试从设备参数加载");
						_logger.LogWarning(ex, "从文件加载电机位置配置异常，将尝试从设备参数加载");
					}
				}

				// 尝试从设备参数加载完整配置
				try
				{
					Console.WriteLine("尝试从设备参数加载电机位置配置");

					// 使用超时机制异步获取设备参数
					var getParametersTask = _deviceParameterService.GetParametersAsync();
					var timeoutTask = Task.Delay(5000); // 5秒超时

					if (Task.WhenAny(getParametersTask, timeoutTask).GetAwaiter().GetResult() == timeoutTask)
					{
						Console.WriteLine("获取设备参数超时，将创建基本默认配置");
						_logger.LogWarning("获取设备参数超时，将创建基本默认配置");
						CreateBasicDefaultPositions();
						return;
					}

					var parameters = getParametersTask.GetAwaiter().GetResult();

					if (parameters != null && parameters.Motors != null && parameters.Motors.Count > 0)
					{
						Console.WriteLine($"成功获取设备参数，找到 {parameters.Motors.Count} 个电机配置");

						// 清空现有配置，加载设备参数中的所有电机工作位置
						try
						{
							_positionsCollection.LoadFromDeviceParameters(parameters.Motors);

							// 输出加载结果
							var motorIds = _positionsCollection.GetAllMotorIds().ToList();
							Console.WriteLine($"从设备参数加载了 {motorIds.Count} 个电机的工作位置配置");

							// 保存到文件
							if (_positionsCollection.SaveToFile(_configFilePath))
							{
								Console.WriteLine($"已将电机位置配置保存到文件: {_configFilePath}");
								_logger.LogInformation($"已将 {motorIds.Count} 个电机的工作位置配置保存到文件");
								return;
							}
						}
						catch (Exception ex)
						{
							Console.WriteLine($"从设备参数加载工作位置失败: {ex.Message}，将创建默认配置");
							_logger.LogWarning($"从设备参数加载工作位置失败: {ex.Message}");
						}
					}
					else
					{
						Console.WriteLine("未获取到有效的电机配置参数，将创建基本默认配置");
						_logger.LogWarning("未获取到有效的电机配置参数，将创建基本默认配置");
					}
				}
				catch (Exception ex)
				{
					Console.WriteLine($"从设备参数加载电机位置配置失败: {ex.Message}");
					_logger.LogWarning(ex, $"从设备参数加载电机位置配置失败");
				}

				// 尝试从注册的电机创建默认配置
				CreateDefaultPositionsFromRegisteredMotors();
			}
			catch (Exception ex)
			{
				Console.WriteLine($"初始化电机位置集合异常: {ex.Message}，将创建基本默认配置");
				_logger.LogError(ex, "初始化电机位置集合异常，将创建基本默认配置");

				// 无论如何都确保有基本默认配置
				CreateBasicDefaultPositions();
			}
		}

		/// <summary>
		/// 从注册的电机创建默认配置
		/// </summary>
		private void CreateDefaultPositionsFromRegisteredMotors()
		{
			try
			{
				Console.WriteLine("从已注册的电机创建默认配置");
				_logger.LogInformation("从已注册的电机创建默认配置");

				// 获取已注册的所有电机
				var registeredMotors = _motors.Keys.ToList();

				if (registeredMotors.Count == 0)
				{
					Console.WriteLine("未发现已注册的电机，使用硬编码的默认配置");
					CreateBasicDefaultPositions();
					return;
				}

				Console.WriteLine($"发现 {registeredMotors.Count} 个已注册的电机，将为它们创建默认位置配置");

				// 遍历所有电机，为每个电机创建默认位置配置
				foreach (var motorId in registeredMotors)
				{
					// 旋转电机的配置
					if (motorId.Contains("Rotary", StringComparison.OrdinalIgnoreCase))
					{
						_positionsCollection.AddOrUpdatePosition(motorId, "Home", new MotorPositionConfig { Position = 0, Speed = 5000, Acceleration = 1000, Deceleration = 1000, PositionTolerance = 10 });
						_positionsCollection.AddOrUpdatePosition(motorId, "Working", new MotorPositionConfig { Position = 60, Speed = 5000, Acceleration = 1000, Deceleration = 1000, PositionTolerance = 10 });
						_positionsCollection.AddOrUpdatePosition(motorId, "SafePosition", new MotorPositionConfig { Position = 90, Speed = 5000, Acceleration = 1000, Deceleration = 1000, PositionTolerance = 10 });
						Console.WriteLine($"已为旋转电机 {motorId} 创建默认位置配置");
					}
					// 升降电机的配置
					else if (motorId.Contains("Lift", StringComparison.OrdinalIgnoreCase))
					{
						_positionsCollection.AddOrUpdatePosition(motorId, "Home", new MotorPositionConfig { Position = 0, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
						_positionsCollection.AddOrUpdatePosition(motorId, "Up", new MotorPositionConfig { Position = 150, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
						_positionsCollection.AddOrUpdatePosition(motorId, "Down", new MotorPositionConfig { Position = 10, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
						_positionsCollection.AddOrUpdatePosition(motorId, "Middle", new MotorPositionConfig { Position = 80, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
						Console.WriteLine($"已为升降电机 {motorId} 创建默认位置配置");
					}
					// 其他电机通用配置
					else
					{
						_positionsCollection.AddOrUpdatePosition(motorId, "Home", new MotorPositionConfig { Position = 0, Speed = 3000, Acceleration = 800, Deceleration = 800, PositionTolerance = 10 });
						_positionsCollection.AddOrUpdatePosition(motorId, "Working", new MotorPositionConfig { Position = 100, Speed = 3000, Acceleration = 800, Deceleration = 800, PositionTolerance = 10 });
						Console.WriteLine($"已为通用电机 {motorId} 创建默认位置配置");
					}
				}

				// 保存到文件
				if (_positionsCollection.SaveToFile(_configFilePath))
				{
					Console.WriteLine($"已将自动创建的电机位置配置保存到文件: {_configFilePath}");
					_logger.LogInformation($"已将自动创建的电机位置配置保存到文件");
				}
				else
				{
					Console.WriteLine("保存自动创建的电机位置配置到文件失败");
					_logger.LogWarning("保存自动创建的电机位置配置到文件失败");
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine($"从已注册电机创建默认配置失败: {ex.Message}，将使用硬编码的默认配置");
				_logger.LogError(ex, "从已注册电机创建默认配置失败，将使用硬编码的默认配置");
				CreateBasicDefaultPositions();
			}
		}

		/// <summary>
		/// 创建基本的默认位置配置（硬编码的最小配置）
		/// </summary>
		private void CreateBasicDefaultPositions()
		{
			Console.WriteLine("创建硬编码的基本默认位置配置");
			_logger.LogInformation("创建硬编码的基本默认位置配置");

			// 如果所有前面的尝试都失败，创建最小默认配置
			_positionsCollection.AddOrUpdatePosition("RotovapRotaryMotor", "Home", new MotorPositionConfig { Position = 0, Speed = 5000, Acceleration = 1000, Deceleration = 1000, PositionTolerance = 10 });
			_positionsCollection.AddOrUpdatePosition("RotovapRotaryMotor", "Working", new MotorPositionConfig { Position = 60, Speed = 5000, Acceleration = 1000, Deceleration = 1000, PositionTolerance = 10 });
			_positionsCollection.AddOrUpdatePosition("RotovapRotaryMotor", "SafePosition", new MotorPositionConfig { Position = 90, Speed = 5000, Acceleration = 1000, Deceleration = 1000, PositionTolerance = 10 });

			_positionsCollection.AddOrUpdatePosition("RotovapLiftMotor", "Home", new MotorPositionConfig { Position = 0, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
			_positionsCollection.AddOrUpdatePosition("RotovapLiftMotor", "Up", new MotorPositionConfig { Position = 150, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
			_positionsCollection.AddOrUpdatePosition("RotovapLiftMotor", "Down", new MotorPositionConfig { Position = 10, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });
			_positionsCollection.AddOrUpdatePosition("RotovapLiftMotor", "Middle", new MotorPositionConfig { Position = 80, Speed = 2000, Acceleration = 500, Deceleration = 500, PositionTolerance = 10 });

			// 保存到文件
			if (_positionsCollection.SaveToFile(_configFilePath))
			{
				Console.WriteLine($"已将基本默认电机位置配置保存到文件: {_configFilePath}");
				_logger.LogInformation("已将基本默认电机位置配置保存到文件");
			}
			else
			{
				Console.WriteLine("保存基本默认电机位置配置到文件失败");
				_logger.LogWarning("保存基本默认电机位置配置到文件失败");
			}
		}

		/// <summary>
		/// 暂停打液
		/// </summary>
		public void PauseDispensing()
		{
			lock (_dispensingLock)
			{
				_isDispensingPaused = true;
			}
		}

		/// <summary>
		/// 恢复打液
		/// </summary>
		public void ResumeDispensing()
		{
			lock (_dispensingLock)
			{
				_isDispensingPaused = false;
			}
		}

		/// <summary>
		/// 获取当前已打液量
		/// </summary>
		public double GetCurrentDispensedVolume()
		{
			lock (_dispensingLock)
			{
				return _currentDispensedVolume;
			}
		}

		/// <summary>
		/// 重置打液量计数
		/// </summary>
		public void ResetDispensedVolume()
		{
			lock (_dispensingLock)
			{
				_currentDispensedVolume = 0;
			}
		}

		/// <summary>
		/// 获取打液是否处于暂停状态
		/// </summary>
		/// <returns>是否暂停</returns>
		public bool IsDispensingPaused()
		{
			lock (_dispensingLock)
			{
				return _isDispensingPaused;
			}
		}

		/// <summary>
		/// 执行打液操作
		/// </summary>
		/// <param name="motorId">泵电机ID</param>
		/// <param name="volumeML">打液量(ml)</param>
		/// <param name="conversionFactor">转换因子(ml/圈)，表示电机每转一圈能够输出的液体量</param>
		/// <param name="speedRPM">打液速度(RPM-每分钟转数)</param>
		/// <returns>操作结果</returns>
		public async Task<OperationResult> DispensingLiquidAsync(string motorId, double volumeML, double conversionFactor, double speedRPM = 60.0)
		{
			try
			{
				// 参数检查
				if (volumeML <= 0)
				{
					return OperationResult.Fail($"打液量必须大于0，当前值: {volumeML}ml");
				}

				if (conversionFactor <= 0)
				{
					return OperationResult.Fail($"转换因子必须大于0，当前值: {conversionFactor}ml/圈");
				}

				if (speedRPM <= 0)
				{
					return OperationResult.Fail($"打液速度必须大于0，当前值: {speedRPM}RPM");
				}

				// 重置打液量计数
				ResetDispensedVolume();

				// 获取电机
				var motor = GetMotor(motorId);
				if (motor == null)
				{
					_logger.LogError($"未找到泵电机: {motorId}");
					return OperationResult.Fail($"未找到泵电机: {motorId}");
				}

				// 获取电机状态
				var status = await motor.GetStatusAsync();
				if (status.Offline)
				{
					_logger.LogError($"泵电机 {motorId} 离线，无法执行打液操作");
					return OperationResult.Fail($"泵电机 {motorId} 离线，无法执行打液操作");
				}

				// 如果电机未使能，则先使能电机
				if (!status.Enabled)
				{
					_logger.LogInformation($"泵电机 {motorId} 未使能，尝试使能电机");
					bool enableResult = await motor.EnableAsync();
					if (!enableResult)
					{
						_logger.LogError($"无法使能泵电机 {motorId}");
						return OperationResult.Fail($"无法使能泵电机 {motorId}");
					}

					// 等待使能完成
					await Task.Delay(100);
				}

				// 计算需要运行的时间(分钟)
				double runTimeMinutes = volumeML / (conversionFactor * speedRPM);

				// 转换为毫秒
				int runTimeMilliseconds = (int)(runTimeMinutes * 60 * 1000);
				int remainingTimeMs = runTimeMilliseconds;

				_logger.LogInformation($"开始打液操作: 电机={motorId}, 体积={volumeML}ml, 转换因子={conversionFactor}ml/圈, " +
									  $"速度={speedRPM}RPM, 计算运行时间={runTimeMinutes:F3}分钟({runTimeMilliseconds}ms)");

				int reportInterval = 1000; // 每秒报告一次状态
				int elapsed = 0;
				bool isRunning = false;

				// 运行时间记录
				var startTime = DateTime.Now;
				DateTime? pauseTime = null;
				int totalPausedMs = 0;

				while (elapsed < runTimeMilliseconds)
				{
					// 检查是否暂停
					bool needJogStart = false;
					bool needJogStop = false;

					// 先在锁内检查状态并设置标志
					lock (_dispensingLock)
					{
						if (_isDispensingPaused && isRunning)
						{
							// 记录暂停时间
							pauseTime = DateTime.Now;
							_logger.LogInformation($"打液操作暂停，已运行 {elapsed / 1000.0:F1} 秒");
							needJogStop = true;
						}
						else if (!_isDispensingPaused && !isRunning)
						{
							// 恢复电机运行
							_logger.LogInformation($"打液操作恢复");

							// 如果之前暂停过，计算暂停时间
							if (pauseTime.HasValue)
							{
								var pauseDuration = (int)(DateTime.Now - pauseTime.Value).TotalMilliseconds;
								totalPausedMs += pauseDuration;
								pauseTime = null;
								_logger.LogInformation($"本次暂停持续了 {pauseDuration / 1000.0:F1} 秒，总暂停时间: {totalPausedMs / 1000.0:F1} 秒");
							}

							needJogStart = true;
						}
					}

					// 锁外执行异步操作
					if (needJogStop)
					{
						var stopResult = await motor.StopJogAsync();
						if (!stopResult)
						{
							_logger.LogWarning($"泵电机 {motorId} 暂停时停止JOG运动失败");
						}
						isRunning = false;
					}
					else if (needJogStart)
					{
						bool jogResult = await motor.JogMinusAsync(speedRPM);
						if (!jogResult)
						{
							_logger.LogError($"泵电机 {motorId} 恢复时启动JOG运动失败");
							return OperationResult.Fail($"泵电机 {motorId} 恢复时启动JOG运动失败");
						}
						isRunning = true;
					}

					// 如果当前处于运行状态
					if (!_isDispensingPaused)
					{
						// 确定当前等待时间段
						int waitTime = Math.Min(reportInterval, runTimeMilliseconds - elapsed);
						await Task.Delay(waitTime);

						// 如果不是暂停状态，累加运行时间
						elapsed += waitTime;

						// 计算当前已打液量并更新
						double estimatedVolumeML = (elapsed / 1000.0 / 60.0) * speedRPM * conversionFactor;
						lock (_dispensingLock)
						{
							_currentDispensedVolume = estimatedVolumeML;
						}

						// 每秒记录一次日志
						if (elapsed % reportInterval == 0 || elapsed >= runTimeMilliseconds)
						{
							double progressPercent = (double)elapsed / runTimeMilliseconds * 100;
							_logger.LogDebug($"泵电机 {motorId} 打液进度: {progressPercent:F1}%, 已运行: {elapsed / 1000.0:F1}秒, 预计已打液: {estimatedVolumeML:F2}ml");
						}

						// 检查电机状态，确保仍在运行
						status = await motor.GetStatusAsync();
						if ((status.Offline || !status.Enabled || !status.Running) && !_isDispensingPaused)
						{
							_logger.LogWarning($"泵电机 {motorId} 状态异常: 离线={status.Offline}, 使能={status.Enabled}, 运动中={status.Running}");

							// 如果电机不再运行，尝试重新启动
							if (!status.Offline && status.Enabled && !status.Running)
							{
								_logger.LogInformation($"尝试重新启动泵电机 {motorId}");
								bool jogResult = await motor.JogMinusAsync(speedRPM);
								if (!jogResult)
								{
									_logger.LogError($"泵电机 {motorId} 重新启动失败");
									return OperationResult.Fail($"泵电机 {motorId} 在打液过程中停止并且无法重新启动");
								}
								isRunning = true;
							}
							else if (status.Offline)
							{
								_logger.LogError($"泵电机 {motorId} 在打液过程中离线");
								return OperationResult.Fail($"泵电机 {motorId} 在打液过程中离线");
							}
						}
						else if (status.Running)
						{
							isRunning = true;
						}
					}
					else
					{
						// 如果处于暂停状态，每100ms检查一次是否恢复
						await Task.Delay(100);
					}
				}

				// 停止JOG运动
				bool finalStopResult = await motor.StopJogAsync();
				if (!finalStopResult)
				{
					_logger.LogWarning($"泵电机 {motorId} 停止JOG运动失败");
				}

				// 计算实际运行时间（包括暂停时间）
				TimeSpan totalDuration = DateTime.Now - startTime;
				double actualRunTimeMinutes = (totalDuration.TotalMilliseconds - totalPausedMs) / 60000.0;

				_logger.LogInformation($"泵电机 {motorId} 打液操作完成，理论打液量: {volumeML}ml, 实际运行时间: {actualRunTimeMinutes:F2}分钟，包含暂停: {totalPausedMs / 1000.0:F1}秒");

				return OperationResult.Ok($"泵电机 {motorId} 打液操作成功，理论打液量: {volumeML:F2}ml，已打液: {_currentDispensedVolume:F2}ml");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"泵电机 {motorId} 打液操作发生异常");

				// 尝试停止可能正在进行的JOG运动
				try
				{
					var motor = GetMotor(motorId);
					if (motor != null)
					{
						await motor.StopJogAsync();
					}
				}
				catch (Exception stopEx)
				{
					_logger.LogError(stopEx, $"尝试停止泵电机 {motorId} JOG运动时发生异常");
				}

				return OperationResult.Fail($"泵电机打液操作发生异常: {ex.Message}");
			}
		}

		/// <summary>
		/// 设备参数更新事件处理
		/// </summary>
		private async void OnDeviceParametersUpdated(object sender, EventArgs e)
		{
			try
			{
				_logger.LogInformation("收到设备参数更新事件，开始同步电机参数和位置");

				// 获取最新的设备参数
				var deviceParams = await _deviceParameterService.GetParametersAsync();

				// 更新电机的通用参数（减速比等）
				if (deviceParams?.Motors != null && deviceParams.Motors.Count > 0)
				{
					_logger.LogInformation("开始更新电机通用参数");
					await SetMotorParametersFromDeviceParams(deviceParams.Motors);
					_logger.LogInformation("电机通用参数更新完成");
				}

				// 同步电机位置配置
				await SyncPositionsFromDeviceParametersAsync();

				_logger.LogInformation("电机参数和位置已根据设备参数更新完成");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, "更新电机参数时发生错误");
			}
		}

		/// <summary>
		/// 释放资源
		/// </summary>
		public void Dispose()
		{
			Dispose(true);
			GC.SuppressFinalize(this);
		}

		/// <summary>
		/// 释放资源
		/// </summary>
		/// <param name="disposing">是否正在释放</param>
		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				if (disposing)
				{
					// 取消订阅事件
					_deviceParameterService.ParametersUpdated -= OnDeviceParametersUpdated;

					// 释放托管资源
					// 保存配置
					try
					{
						SavePositionConfigAsync().Wait();
					}
					catch (Exception ex)
					{
						_logger.LogError(ex, "释放电机控制服务资源时保存配置失败");
					}
				}

				// 释放非托管资源

				_disposed = true;
			}
		}
	}
}